# 列表的CRUD操作
def func_print(obj, func_name=None):
    """对自定义打印函数，对打印结果作声明"""
    symbol1 = "\n###############################################################\n"
    symbol2 = symbol1+f"{obj}的{func_name}操作"+symbol1
    print(symbol2)


###############################################################
# 列表的增加操作
###############################################################
def list_create(list1, list2):
    """两个列表相加"""
    your_list = list1+list2
    print(f'{list1}+{list2}的结果是{your_list}')
    return your_list


def list_mul(list1, times=1):
    """对列表进行自我复制加大"""
    your_list = times*list1
    print(f'{times}*{list1}的结果是{your_list}')
    return your_list


def list_append(list1, value):
    """在列表结尾插入一个值"""
    list1.append(value)
    print(f'在结尾插入{value} 的结果是{list1}')
    return list1


def list_insert(list1, index=-1, value=None):
    """在列表中的指定位置插入一个值"""
    list1.insert(index, value)
    print(f'在索引\t{index}\t插入\t{value}\t的结果是{list1}')
    return list1


###############################################################
# 列表的检索操作
###############################################################
def list_cut(list1, start=None, end=None):
    """对列表中的元素进行切片"""
    your_list = list1[start:end]
    print(f'对{list1}进行切片操作后的结果是{your_list}')
    return your_list


def list_index(list1, value):
    """对列表中的某一元素查找索引"""
    try:
        print(f'在{list1}中\t{value}\t的索引值是\t{list1.index(value)}\t')
        return list1.index(value)
    except (RuntimeError, TypeError, NameError, ValueError):
        print('你要找的值不在列表中')
        return None


###############################################################
# 列表的更新操作
###############################################################
def list_cut_update(list1, index, value=None):
    """对列表中的指定元素进行更改"""
    list1[index] = value
    print(f"列表中索引为\t{index}\t的值改为\t{value}\t的结果是{list1}")
    return list1


###############################################################
# 列表的删除操作
###############################################################
def list_pop(list1):
    """对列表中的末尾元素进行删除"""
    list1.pop()
    print(f'列表进行pop操作后为{list1}')
    return list1


def list_remove(list1, value):
    """对列表中的某一元素进行删除"""
    list1.remove(value)
    print(f'列表进行remove\t{value}\t操作后为{list1}')
    return list1


###############################################################
# 列表的统计操作
###############################################################
def list_count(list1, value):
    """对列表中的某一元素进行数量统计"""
    print(f'{list1}中\t{value}\t数量有\t{list1.count(value)}\t')
    return list1.count(value)


###############################################################
# 列表的排序操作
###############################################################
def list_reverse(list1):
    """对列表中的元素进行倒序排序，返回None"""
    list1.reverse()
    print(f'对列表进行reverse操作后结果为{list1}')
    return None


def list_reversed(list1):
    """对列表中的元素进行倒序排序，返回排序后的迭代器，记得使用list()转换"""
    your_list = list(reversed(list1))
    print(f'对列表进行reversed操作后结果为{your_list}')
    return your_list


def list_sort(list1):
    """对列表中的元素进行顺序排序，返回None"""
    list1.sort()
    print(f'对列表进行sort操作后结果为{list1}')
    return None


def list_sorted(list1):
    """对列表中的元素进行顺序排序，返回排序后的迭代器，记得使用list()转换"""
    your_list = list(sorted(list1))
    print(f'对列表进行sorted操作后结果为{your_list}')
    return your_list


###############################################################
# 元组的创建操作
###############################################################
def tuple_create(tuple1, tuple2):
    """两个元组相加"""
    your_tuple = tuple1+tuple2
    print(f'元组{tuple1}+{tuple2}的结果是{your_tuple}')
    return your_tuple


###############################################################
# 元组的检索操作
###############################################################
def tuple_cut(tuple1, start=None, end=None):
    """对元组中的元素进行切片"""
    your_tuple = tuple1[start:end]
    print(f'对元组{tuple1}进行切片操作后的结果是{your_tuple}')
    return your_tuple


def tuple_index(tuple1, value):
    """对元组中的某一元素查找索引"""
    try:
        print(f'在元组{tuple1}中\t{value}\t的索引值是\t{tuple1.index(value)}\t')
        return tuple1.index(value)
    except (RuntimeError, TypeError, NameError, ValueError):
        print('你要找的值不在元组中')
        return None
###############################################################
# 元组的更新操作
###############################################################

###############################################################
# 元组的删除操作
###############################################################

###############################################################
# 字典的增加操作
###############################################################
def dict_add(dict1={}, key=None, value=None):
    """字典的键对值赋值"""
    dict1[key] = value
    print(f'字典增加键对值{key}：{value}后的结果是{dict1}')
    return dict1


def dict_update(dict1={}, dict2={}):
    """字典的更新操作,返回None"""
    dict1.update(dict2)
    print(f'字典的update操作后的结果是{dict1}')
    return dict1


def dict_set_value(dict1={}, key=None, value=None):
    """对字典的某一个键的值进行修改"""
    dict1.setdefault(key, value)
    print(f'对字典的{key}进行setdeafault操作后的结果为{dict1}')
    return dict1


###############################################################
# 字典的检索操作
###############################################################
def dict_key_retrieve(dict1={}, key=None):
    """通过键对字典进行索引"""
    print(f'字典的键 {key} 的值为 {dict1[key]} ')
    return dict1[key]


def dict_get_value(dict1={}, key=None, default_value=None):
    """如果有值，则返回该值；如果没有值，返回默认值"""
    print(f'字典的键 {key} 的值为 {dict1.get(key, default_value)}')
    return dict1.get(key, default_value)


def dict_get_keys(dict1={}):
    """获取字典的所有key"""
    print(f'字典的键为{list(dict1.keys())}')
    return list(dict1.keys())


def dict_get_values(dict1={}):
    """获取字典的所有value"""
    print(f'字典的键值为{list(dict1.values())}')
    return list(dict1.values())


def dict_get_items(dict1={}):
    """获取字典的所有value"""
    print(f'字典的键值对为{list(dict1.items())}')
    return list(dict1.items())


###############################################################
# 字典的更新操作
###############################################################
def dict_set(dict1={}, key=None, value=None):
    """通过键对值更新字典"""
    dict1[key] = value
    print(f'对字典进行键对值更新操作后的结果是{dict1}')
    return dict1


def dict_update(dict1={}, dict2={}):
    """通把字典dict2的键/值对更新到dict1里"""
    dict1.update(dict2)
    print(f'对字典update操作后的结果是{dict1}')
    return dict1


###############################################################
# 字典的删除操作
###############################################################
def dict_pop(dict1={}, key=None, value=None):
    """对字典指定key删除"""
    dict1.pop(key, value)
    print(f'对字典进行pop操作后的结果是{dict1}')
    return dict1


def dict_clear(dict1={}):
    """对字典进行删除"""
    dict1.clear()
    print(f'对字典进行clear操作的结果是{dict1}')
    return dict1


###############################################################
# 集合的增加操作
###############################################################
def set_add(set1, key):
    """对字典进行增加操作"""
    set1.add(key)
    print(f'对集合进行增加操作后的结果是{set1}')
    return set1


###############################################################
# 集合的检索操作
###############################################################
def set_in(set1, key):
    """判断元素是否在字典中"""
    if key in set1:
        print(f'{key}在集合中')
    else:
        print(f'{key}不在在集合中')
    return key in set1


###############################################################
# 集合的更新操作
###############################################################
def set_update(set1, set2):
    """将set2的元素合并到set1中"""
    set1.update(set2)
    print(f'合并后的结果是{list(set1)}')
    return set1


def set_union(set1, set2):
    """将set1和set2合并"""
    print(f'合并后的结果是{list(set1.union(set2))}')
    return set1.union(set2)

###############################################################
# 集合的删除操作
###############################################################


def set_remove(set1, key):
    """删除集合里的元素"""
    try:
        set1.remove(key)
        print(f'进行remove操作后的结果是{set1}')
    except KeyError:
        print(f'{key}不在集合中')
    finally:
        pass
    return set1


def set_discard(set1, key):
    """删除集合里的元素"""
    set1.discard(key)
    print(f'进行discard操作后的结果是{set1}')
    return set1


def set_pop(set1):
    """删除集合里某一个元素"""
    set1.pop()
    print(f'进行pop操作后的结果是{set1}')
    return set1


if __name__ == '__main__':
    # 列表
    func_print("列表", "增加")
    list_create([1, 2], [3, 4])
    list_mul([1, 2], 3)
    list_append([1, 2], 5)
    list_insert([1, 2], 1, 3)

    func_print("列表", "检索")
    list_cut([1, 2, 3, 5, 6], 2, 4)
    list_cut([1, 2, 3, 5, 6])
    list_index([1, 2, 3, 5, 6], 5)
    list_index([1, 2, 3, 5, 6], 4)

    func_print("列表", "更新")
    list_cut_update([1, 2, 3, 4, 5], 3, 6)

    func_print("列表", "删除")
    list_pop([1, 2, 3, 4, 5, 6])
    list_remove([1, 2, 3, 4, 5, 6], 5)

    func_print("列表", "计数")
    list_count([1, 2, 3, 5], 3)
    list_count([1, 2, 3, 5], 4)

    func_print("列表", "排序")
    list_reverse([1, 2, 3, 5])
    list_reversed([1, 2, 3, 5])
    list_sort([1, 2, 3, 5])
    list_sorted([1, 2, 3, 5])

    # 元组
    func_print("元组", "创建")
    tuple_create((1, 2), (3, 4))
    func_print("元组", "索引")
    tuple_cut((1, 2, 3, 4), 1, 3)
    tuple_index((1, 2, 3, 4), 2)

    # 字典
    func_print("字典", "增加")
    dict_add({}, 'a', 1)
    dict_update({'a': 1, 'b': 2}, {'c': 3, 'd': 4})
    dict_set_value({'a': 1, 'b': 2}, 'a', 3)
    dict_set_value({'a': 1, 'b': 2}, 'c', 3)

    func_print("字典", "检索")
    dict_key_retrieve({'a': 1, 'b': 2}, 'b')
    dict_get_value({'a': 1, 'b': 2}, 'b', 3)
    dict_get_keys({'a': 1, 'b': 2})
    dict_get_values({'a': 1, 'b': 2})
    dict_get_items({'a': 1, 'b': 2})

    func_print("字典", "更新")
    dict_set({'a': 1, 'b': 2}, 'c', 3)
    dict_update({'a': 1, 'b': 2}, {'c': 3})

    func_print("字典", "删除")
    dict_pop({'a': 1, 'b': 2}, 'b')
    dict_clear({'a': 1, 'b': 2})

    # 集合
    func_print("集合", "增加")
    set_add({'b'}, 'a')

    func_print("集合", "检索")
    set_in({'a', 'b', 'c'}, 'a')
    set_in({'a', 'b', 'c'}, 'd')

    func_print("集合", "更新")
    set_update({'a', 'b', 'c'}, {'d'})
    set_union({'a', 'b', 'c'}, {'d'})

    func_print("集合", "删除")
    set_remove({'a', 'b', 'c'}, 'c')
    set_remove({'a', 'b', 'c'}, 'd')
    set_discard({'a', 'b', 'c'}, 'c')
    set_pop({'b', 'a', 'c'})




